home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / email / message.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  14.0 KB  |  536 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. __all__ = [
  5.     'Message']
  6. import re
  7. import uu
  8. import binascii
  9. import warnings
  10. from cStringIO import StringIO
  11. import email.charset as email
  12. from email import utils
  13. from email import errors
  14. SEMISPACE = '; '
  15. paramre = re.compile('\\s*;\\s*')
  16. tspecials = re.compile('[ \\(\\)<>@,;:\\\\"/\\[\\]\\?=]')
  17.  
  18. def _formatparam(param, value = None, quote = True):
  19.     if value is not None and len(value) > 0:
  20.         if isinstance(value, tuple):
  21.             param += '*'
  22.             value = utils.encode_rfc2231(value[2], value[0], value[1])
  23.         
  24.         if quote or tspecials.search(value):
  25.             return '%s="%s"' % (param, utils.quote(value))
  26.         else:
  27.             return '%s=%s' % (param, value)
  28.     else:
  29.         return param
  30.  
  31.  
  32. def _parseparam(s):
  33.     plist = []
  34.     while s[:1] == ';':
  35.         s = s[1:]
  36.         end = s.find(';')
  37.         while end > 0 and s.count('"', 0, end) % 2:
  38.             end = s.find(';', end + 1)
  39.         if end < 0:
  40.             end = len(s)
  41.         
  42.         f = s[:end]
  43.         if '=' in f:
  44.             i = f.index('=')
  45.             f = f[:i].strip().lower() + '=' + f[i + 1:].strip()
  46.         
  47.         plist.append(f.strip())
  48.         s = s[end:]
  49.     return plist
  50.  
  51.  
  52. def _unquotevalue(value):
  53.     if isinstance(value, tuple):
  54.         return (value[0], value[1], utils.unquote(value[2]))
  55.     else:
  56.         return utils.unquote(value)
  57.  
  58.  
  59. class Message:
  60.     
  61.     def __init__(self):
  62.         self._headers = []
  63.         self._unixfrom = None
  64.         self._payload = None
  65.         self._charset = None
  66.         self.preamble = None
  67.         self.epilogue = None
  68.         self.defects = []
  69.         self._default_type = 'text/plain'
  70.  
  71.     
  72.     def __str__(self):
  73.         return self.as_string(unixfrom = True)
  74.  
  75.     
  76.     def as_string(self, unixfrom = False):
  77.         Generator = Generator
  78.         import email.Generator
  79.         fp = StringIO()
  80.         g = Generator(fp)
  81.         g.flatten(self, unixfrom = unixfrom)
  82.         return fp.getvalue()
  83.  
  84.     
  85.     def is_multipart(self):
  86.         return isinstance(self._payload, list)
  87.  
  88.     
  89.     def set_unixfrom(self, unixfrom):
  90.         self._unixfrom = unixfrom
  91.  
  92.     
  93.     def get_unixfrom(self):
  94.         return self._unixfrom
  95.  
  96.     
  97.     def attach(self, payload):
  98.         if self._payload is None:
  99.             self._payload = [
  100.                 payload]
  101.         else:
  102.             self._payload.append(payload)
  103.  
  104.     
  105.     def get_payload(self, i = None, decode = False):
  106.         if i is None:
  107.             payload = self._payload
  108.         elif not isinstance(self._payload, list):
  109.             raise TypeError('Expected list, got %s' % type(self._payload))
  110.         else:
  111.             payload = self._payload[i]
  112.         if decode:
  113.             if self.is_multipart():
  114.                 return None
  115.             
  116.             cte = self.get('content-transfer-encoding', '').lower()
  117.             if cte == 'quoted-printable':
  118.                 return utils._qdecode(payload)
  119.             elif cte == 'base64':
  120.                 
  121.                 try:
  122.                     return utils._bdecode(payload)
  123.                 except binascii.Error:
  124.                     return payload
  125.                 except:
  126.                     None<EXCEPTION MATCH>binascii.Error
  127.                 
  128.  
  129.             None<EXCEPTION MATCH>binascii.Error
  130.             if cte in ('x-uuencode', 'uuencode', 'uue', 'x-uue'):
  131.                 sfp = StringIO()
  132.                 
  133.                 try:
  134.                     uu.decode(StringIO(payload + '\n'), sfp, quiet = True)
  135.                     payload = sfp.getvalue()
  136.                 except uu.Error:
  137.                     return payload
  138.                 except:
  139.                     None<EXCEPTION MATCH>uu.Error
  140.                 
  141.  
  142.             None<EXCEPTION MATCH>uu.Error
  143.         
  144.         return payload
  145.  
  146.     
  147.     def set_payload(self, payload, charset = None):
  148.         self._payload = payload
  149.         if charset is not None:
  150.             self.set_charset(charset)
  151.         
  152.  
  153.     
  154.     def set_charset(self, charset):
  155.         if charset is None:
  156.             self.del_param('charset')
  157.             self._charset = None
  158.             return None
  159.         
  160.         if isinstance(charset, basestring):
  161.             charset = email.charset.Charset(charset)
  162.         
  163.         if not isinstance(charset, email.charset.Charset):
  164.             raise TypeError(charset)
  165.         
  166.         self._charset = charset
  167.         if not self.has_key('MIME-Version'):
  168.             self.add_header('MIME-Version', '1.0')
  169.         
  170.         if not self.has_key('Content-Type'):
  171.             self.add_header('Content-Type', 'text/plain', charset = charset.get_output_charset())
  172.         else:
  173.             self.set_param('charset', charset.get_output_charset())
  174.         if str(charset) != charset.get_output_charset():
  175.             self._payload = charset.body_encode(self._payload)
  176.         
  177.         if not self.has_key('Content-Transfer-Encoding'):
  178.             cte = charset.get_body_encoding()
  179.             
  180.             try:
  181.                 cte(self)
  182.             except TypeError:
  183.                 self._payload = charset.body_encode(self._payload)
  184.                 self.add_header('Content-Transfer-Encoding', cte)
  185.             except:
  186.                 None<EXCEPTION MATCH>TypeError
  187.             
  188.  
  189.         None<EXCEPTION MATCH>TypeError
  190.  
  191.     
  192.     def get_charset(self):
  193.         return self._charset
  194.  
  195.     
  196.     def __len__(self):
  197.         return len(self._headers)
  198.  
  199.     
  200.     def __getitem__(self, name):
  201.         return self.get(name)
  202.  
  203.     
  204.     def __setitem__(self, name, val):
  205.         self._headers.append((name, val))
  206.  
  207.     
  208.     def __delitem__(self, name):
  209.         name = name.lower()
  210.         newheaders = []
  211.         for k, v in self._headers:
  212.             if k.lower() != name:
  213.                 newheaders.append((k, v))
  214.                 continue
  215.         
  216.         self._headers = newheaders
  217.  
  218.     
  219.     def __contains__(self, name):
  220.         return [] in [ k.lower() for k, v in self._headers ]
  221.  
  222.     
  223.     def has_key(self, name):
  224.         missing = object()
  225.         return self.get(name, missing) is not missing
  226.  
  227.     
  228.     def keys(self):
  229.         return [ k for k, v in self._headers ]
  230.  
  231.     
  232.     def values(self):
  233.         return [ v for k, v in self._headers ]
  234.  
  235.     
  236.     def items(self):
  237.         return self._headers[:]
  238.  
  239.     
  240.     def get(self, name, failobj = None):
  241.         name = name.lower()
  242.         for k, v in self._headers:
  243.             if k.lower() == name:
  244.                 return v
  245.                 continue
  246.         
  247.         return failobj
  248.  
  249.     
  250.     def get_all(self, name, failobj = None):
  251.         values = []
  252.         name = name.lower()
  253.         for k, v in self._headers:
  254.             if k.lower() == name:
  255.                 values.append(v)
  256.                 continue
  257.         
  258.         if not values:
  259.             return failobj
  260.         
  261.         return values
  262.  
  263.     
  264.     def add_header(self, _name, _value, **_params):
  265.         parts = []
  266.         for k, v in _params.items():
  267.             if v is None:
  268.                 parts.append(k.replace('_', '-'))
  269.                 continue
  270.             parts.append(_formatparam(k.replace('_', '-'), v))
  271.         
  272.         if _value is not None:
  273.             parts.insert(0, _value)
  274.         
  275.         self._headers.append((_name, SEMISPACE.join(parts)))
  276.  
  277.     
  278.     def replace_header(self, _name, _value):
  279.         _name = _name.lower()
  280.         for k, v in zip(range(len(self._headers)), self._headers):
  281.             if k.lower() == _name:
  282.                 self._headers[i] = (k, _value)
  283.                 break
  284.                 continue
  285.         else:
  286.             raise KeyError(_name)
  287.  
  288.     
  289.     def get_content_type(self):
  290.         missing = object()
  291.         value = self.get('content-type', missing)
  292.         if value is missing:
  293.             return self.get_default_type()
  294.         
  295.         ctype = paramre.split(value)[0].lower().strip()
  296.         if ctype.count('/') != 1:
  297.             return 'text/plain'
  298.         
  299.         return ctype
  300.  
  301.     
  302.     def get_content_maintype(self):
  303.         ctype = self.get_content_type()
  304.         return ctype.split('/')[0]
  305.  
  306.     
  307.     def get_content_subtype(self):
  308.         ctype = self.get_content_type()
  309.         return ctype.split('/')[1]
  310.  
  311.     
  312.     def get_default_type(self):
  313.         return self._default_type
  314.  
  315.     
  316.     def set_default_type(self, ctype):
  317.         self._default_type = ctype
  318.  
  319.     
  320.     def _get_params_preserve(self, failobj, header):
  321.         missing = object()
  322.         value = self.get(header, missing)
  323.         if value is missing:
  324.             return failobj
  325.         
  326.         params = []
  327.         for p in _parseparam(';' + value):
  328.             
  329.             try:
  330.                 (name, val) = p.split('=', 1)
  331.                 name = name.strip()
  332.                 val = val.strip()
  333.             except ValueError:
  334.                 name = p.strip()
  335.                 val = ''
  336.  
  337.             params.append((name, val))
  338.         
  339.         params = utils.decode_params(params)
  340.         return params
  341.  
  342.     
  343.     def get_params(self, failobj = None, header = 'content-type', unquote = True):
  344.         missing = object()
  345.         params = self._get_params_preserve(missing, header)
  346.         if params is missing:
  347.             return failobj
  348.         
  349.  
  350.     
  351.     def get_param(self, param, failobj = None, header = 'content-type', unquote = True):
  352.         if not self.has_key(header):
  353.             return failobj
  354.         
  355.         for k, v in self._get_params_preserve(failobj, header):
  356.             if k.lower() == param.lower():
  357.                 if unquote:
  358.                     return _unquotevalue(v)
  359.                 else:
  360.                     return v
  361.             unquote
  362.         
  363.         return failobj
  364.  
  365.     
  366.     def set_param(self, param, value, header = 'Content-Type', requote = True, charset = None, language = ''):
  367.         if not isinstance(value, tuple) and charset:
  368.             value = (charset, language, value)
  369.         
  370.         if not self.has_key(header) and header.lower() == 'content-type':
  371.             ctype = 'text/plain'
  372.         else:
  373.             ctype = self.get(header)
  374.         if not self.get_param(param, header = header):
  375.             if not ctype:
  376.                 ctype = _formatparam(param, value, requote)
  377.             else:
  378.                 ctype = SEMISPACE.join([
  379.                     ctype,
  380.                     _formatparam(param, value, requote)])
  381.         else:
  382.             ctype = ''
  383.             for old_param, old_value in self.get_params(header = header, unquote = requote):
  384.                 append_param = ''
  385.                 if old_param.lower() == param.lower():
  386.                     append_param = _formatparam(param, value, requote)
  387.                 else:
  388.                     append_param = _formatparam(old_param, old_value, requote)
  389.                 if not ctype:
  390.                     ctype = append_param
  391.                     continue
  392.                 ctype = SEMISPACE.join([
  393.                     ctype,
  394.                     append_param])
  395.             
  396.         if ctype != self.get(header):
  397.             del self[header]
  398.             self[header] = ctype
  399.         
  400.  
  401.     
  402.     def del_param(self, param, header = 'content-type', requote = True):
  403.         if not self.has_key(header):
  404.             return None
  405.         
  406.         new_ctype = ''
  407.         for p, v in self.get_params(header = header, unquote = requote):
  408.             if p.lower() != param.lower():
  409.                 if not new_ctype:
  410.                     new_ctype = _formatparam(p, v, requote)
  411.                 else:
  412.                     new_ctype = SEMISPACE.join([
  413.                         new_ctype,
  414.                         _formatparam(p, v, requote)])
  415.             new_ctype
  416.         
  417.         if new_ctype != self.get(header):
  418.             del self[header]
  419.             self[header] = new_ctype
  420.         
  421.  
  422.     
  423.     def set_type(self, type, header = 'Content-Type', requote = True):
  424.         if not type.count('/') == 1:
  425.             raise ValueError
  426.         
  427.         if header.lower() == 'content-type':
  428.             del self['mime-version']
  429.             self['MIME-Version'] = '1.0'
  430.         
  431.         if not self.has_key(header):
  432.             self[header] = type
  433.             return None
  434.         
  435.         params = self.get_params(header = header, unquote = requote)
  436.         del self[header]
  437.         self[header] = type
  438.         for p, v in params[1:]:
  439.             self.set_param(p, v, header, requote)
  440.         
  441.  
  442.     
  443.     def get_filename(self, failobj = None):
  444.         missing = object()
  445.         filename = self.get_param('filename', missing, 'content-disposition')
  446.         if filename is missing:
  447.             filename = self.get_param('name', missing, 'content-disposition')
  448.         
  449.         if filename is missing:
  450.             return failobj
  451.         
  452.         return utils.collapse_rfc2231_value(filename).strip()
  453.  
  454.     
  455.     def get_boundary(self, failobj = None):
  456.         missing = object()
  457.         boundary = self.get_param('boundary', missing)
  458.         if boundary is missing:
  459.             return failobj
  460.         
  461.         return utils.collapse_rfc2231_value(boundary).rstrip()
  462.  
  463.     
  464.     def set_boundary(self, boundary):
  465.         missing = object()
  466.         params = self._get_params_preserve(missing, 'content-type')
  467.         if params is missing:
  468.             raise errors.HeaderParseError('No Content-Type header found')
  469.         
  470.         newparams = []
  471.         foundp = False
  472.         for pk, pv in params:
  473.             if pk.lower() == 'boundary':
  474.                 newparams.append(('boundary', '"%s"' % boundary))
  475.                 foundp = True
  476.                 continue
  477.             newparams.append((pk, pv))
  478.         
  479.         if not foundp:
  480.             newparams.append(('boundary', '"%s"' % boundary))
  481.         
  482.         newheaders = []
  483.         for h, v in self._headers:
  484.             if h.lower() == 'content-type':
  485.                 parts = []
  486.                 for k, v in newparams:
  487.                     if v == '':
  488.                         parts.append(k)
  489.                         continue
  490.                     parts.append('%s=%s' % (k, v))
  491.                 
  492.                 newheaders.append((h, SEMISPACE.join(parts)))
  493.                 continue
  494.             newheaders.append((h, v))
  495.         
  496.         self._headers = newheaders
  497.  
  498.     
  499.     def get_content_charset(self, failobj = None):
  500.         missing = object()
  501.         charset = self.get_param('charset', missing)
  502.         if charset is missing:
  503.             return failobj
  504.         
  505.         if isinstance(charset, tuple):
  506.             if not charset[0]:
  507.                 pass
  508.             pcharset = 'us-ascii'
  509.             
  510.             try:
  511.                 charset = unicode(charset[2], pcharset).encode('us-ascii')
  512.             except (LookupError, UnicodeError):
  513.                 charset = charset[2]
  514.             except:
  515.                 None<EXCEPTION MATCH>(LookupError, UnicodeError)
  516.             
  517.  
  518.         None<EXCEPTION MATCH>(LookupError, UnicodeError)
  519.         
  520.         try:
  521.             if isinstance(charset, str):
  522.                 charset = unicode(charset, 'us-ascii')
  523.             
  524.             charset = charset.encode('us-ascii')
  525.         except UnicodeError:
  526.             return failobj
  527.  
  528.         return charset.lower()
  529.  
  530.     
  531.     def get_charsets(self, failobj = None):
  532.         return [ part.get_content_charset(failobj) for part in self.walk() ]
  533.  
  534.     from email.Iterators import walk
  535.  
  536.